using DG.Tweening;
using System.Collections.Generic;
using UnityEngine.UI;
using UnityEngine;
using System.Collections;
using System.Linq;

/// <summary>
/// 麻将胡乐游戏UI控制器
/// 控制麻将机的滚动动画和消除逻辑
/// </summary>
public class MaJiangHuLe_UICtrl : UIControl
{
    [Header("游戏参数")]
    public int columns = 5;             // 麻将列数
    public int rows = 4;                // 麻将行数
    public float scrollDuration = 5f;   // 滚动动画持续时间（秒）
    public float scrollSpeed = 0.5f;    // 滚动速度（值越小越快）
    public int triggerValue = 7;        // 触发麻将消除值

    [Header("动画设置")]
    public bool useSequentialStop = true;    // 是否使用从左至右依次停止
    public float startInterval = 0.2f;  // 列启动间隔
    public float stopInterval = 0.3f;        // 每列停止间隔时间
    public float smoothStopDuration = 1.0f;  // 平滑停止持续时间
    public AnimationCurve stopCurve = AnimationCurve.EaseInOut(0, 0, 1, 1); // 停止曲线

    /// <summary>
    /// 对应GUI/UISource/MaJiang下面的1~42个图片
    /// </summary>
    [Header("数值范围")]
    public int minValue = 1;            // 麻将显示数值最小值
    public int maxValue = 42;            // 麻将显示数值最大值

    // 私有变量
    private GameObject buttonPrefab;    // 麻将按钮预制体
    private RectTransform buttonGridPanel; // 麻将网格面板
    private RectTransform gameAreaPanel;   // 游戏区域面板（滚动容器）
    private GridLayoutGroup gridLayout; // 网格布局组件
    private Mask gridMask;              // 网格遮罩
    private CardGridButton_UICtrl[,] buttons; // 二维数组存储所有麻将按钮

    private bool isScrolling = false;   // 是否正在滚动中
    private bool isRefilling = false;   // 是否正在重新填充麻将
    private Coroutine[] columnCoroutines; // 每列的滚动协程
    private float[] columnStopTimes;    // 每列的停止时间
    private bool[] columnStopped;       // 每列是否已停止
   

    #region 初始化Grid

    void Start()
    {
        // 加载麻将按钮预制体
        buttonPrefab = ResMgr.Instance.LoadAsset<GameObject>("GUI/UI_Prefabs/CardGridButton.prefab");

        // 获取UI组件引用
        gameAreaPanel = this.viewDic["/GameAreaPanel"].GetComponent<RectTransform>();
        buttonGridPanel = this.viewDic["/GameAreaPanel/ButtonGridPanel"].GetComponent<RectTransform>();
        gridLayout = buttonGridPanel.GetComponent<GridLayoutGroup>();

        // 确保网格有遮罩组件，只显示游戏区域内的麻将牌
        gridMask = buttonGridPanel.GetComponent<Mask>() ?? buttonGridPanel.gameObject.AddComponent<Mask>();
        gridMask.showMaskGraphic = false; // 不显示遮罩图形，只使用裁剪功能
         
        // 添加开始按钮监听
        base.AddButtonListener("/ButtomAreaPanel/StartButton", OnStartButtonClick);

        // 在布局完成后初始化，确保UI尺寸正确
        StartCoroutine(InitializeAfterLayout());
    }

    /// <summary>
    /// 在布局完成后初始化
    /// 等待一帧确保UI布局系统完成计算
    /// </summary>
    IEnumerator InitializeAfterLayout()
    {
        // 等待一帧让Unity的布局系统完成计算
        yield return null;

        // 初始化麻将网格，创建指定数量的麻将按钮，设置初始值
        Debug.Log("=== 开始初始化麻将网格 ===");
        Debug.Log($"网格尺寸: {columns}列 × {rows}行 = {columns * rows}个麻将");

        // 创建按钮数组
        buttons = new CardGridButton_UICtrl[columns, rows];

        // 清除现有按钮（如果有的话）
        int existingCount = buttonGridPanel.childCount;
        if (existingCount > 0)
        {
            Debug.Log($"清除现有麻将: {existingCount}个");
            foreach (Transform child in buttonGridPanel)
            {
                Destroy(child.gameObject);
            }
        }

        // 获取网格布局参数
        Vector2 cellSize = gridLayout.cellSize;
        Vector2 spacing = gridLayout.spacing;

        Debug.Log($"单元格尺寸: {cellSize}, 间距: {spacing}");

        // 创建所有麻将按钮
        int createdCount = 0;
        for (int col = 0; col < columns; col++)
        {
            for (int row = 0; row < rows; row++)
            {
                // 实例化麻将按钮
                GameObject btnObj = Instantiate(buttonPrefab, buttonGridPanel);
                btnObj.transform.localScale = Vector3.one;

                // 获取或添加麻将按钮控制器
                CardGridButton_UICtrl btn = btnObj.GetComponent<CardGridButton_UICtrl>() ?? btnObj.AddComponent<CardGridButton_UICtrl>();

                // 设置麻将值（中心位置为触发值，其他为随机值）
                int value = (col == 2 && row == 2) ? triggerValue : Random.Range(minValue, maxValue + 1);
                btn.SetValue(value, triggerValue);
                

                // 存储按钮引用
                buttons[col, row] = btn;

                // 设置按钮位置
                btnObj.transform.localPosition = GetGridPosition(col, row, cellSize, spacing);

                createdCount++;
                Debug.Log($"创建麻将[{col},{row}]: 值={value}, 位置={btnObj.transform.localPosition}");
            }
        }

        Debug.Log($"初始化完成，创建了 {createdCount} 个麻将");

        // 更新内容尺寸
          UpdateContentSize();

        // 验证初始化后的麻将数量
        //ValidateButtonArray();

        Debug.Log("=== 初始化麻将网格完成 ===");
    }

    /// <summary>
    /// 更新内容尺寸以匹配网格布局
    /// </summary>
    void UpdateContentSize()
    {
        // 获取网格参数
        Vector2 cellSize = gridLayout.cellSize;
        Vector2 spacing = gridLayout.spacing;

        // 确保单元格尺寸有效
        if (cellSize.x <= 0 || cellSize.y <= 0)
        {
            Debug.LogWarning($"无效的单元格尺寸: {cellSize}. 使用默认值 100x100");
            cellSize = new Vector2(100, 100);
        }

        // 计算网格总尺寸
        float width = columns * (cellSize.x + spacing.x) - spacing.x;
        float height = rows * (cellSize.y + spacing.y) - spacing.y;

        // 确保尺寸有效
        if (width <= 0 || height <= 0)
        {
            Debug.LogWarning($"计算出的无效尺寸: {width}x{height}. 使用默认值 500x400");
            width = 500;
            height = 400;
        }

        // 设置网格面板尺寸
        buttonGridPanel.sizeDelta = new Vector2(width, height);

        // 确保游戏区域面板与网格尺寸匹配
        //if (gameAreaPanel != null)
        //{
        //    gameAreaPanel.sizeDelta = buttonGridPanel.sizeDelta;
        //}
    }
    #endregion

    #region 点击开始

    /// <summary>
    /// 开始按钮点击事件处理
    /// </summary>
    public void OnStartButtonClick()
    {
        // 防止在滚动过程中或重新填充时开始新的滚动
        if (!isScrolling && !isRefilling)
        {
            StartCoroutine(ScrollRoutine());
        }
    }

    /// <summary>
    /// 滚动协程 - 控制整体滚动流程
    /// </summary>
    IEnumerator ScrollRoutine()
    {
        isScrolling = true;
        columnCoroutines = new Coroutine[columns];
        columnStopTimes = new float[columns];
        columnStopped = new bool[columns];

        // 初始化停止时间 - 现在每列独立计算停止时间
        for (int col = 0; col < columns; col++)
        {
            // 每列滚动时间 = 基础滚动时间 + 列索引 * 停止间隔
            columnStopTimes[col] = scrollDuration + col * stopInterval;
            columnStopped[col] = false;
        }

        // 为每列创建临时容器
        GameObject[] tempContainers = new GameObject[columns];
        for (int col = 0; col < columns; col++)
        {
            tempContainers[col] = new GameObject($"TempContainer_{col}");
            tempContainers[col].transform.SetParent(buttonGridPanel);
            tempContainers[col].transform.localPosition = Vector3.zero;
            tempContainers[col].transform.localScale = Vector3.one;

            // 将麻将移动到临时容器
            for (int row = 0; row < rows; row++)
            {
                if (buttons[col, row] != null)
                {
                    buttons[col, row].transform.SetParent(tempContainers[col].transform);
                }
            }
        }

        // 依次启动每列滚动（第一列到第五列）
        for (int col = 0; col < columns; col++)
        {
            // 启动当前列滚动
            columnCoroutines[col] = StartCoroutine(ScrollColumn(col, tempContainers[col]));

            // 等待列间启动间隔
            if (col < columns - 1)
            {
                yield return new WaitForSeconds(startInterval);
            }
        }

        // 计算最大等待时间（最后一列的停止时间 + 平滑时间）
        float maxWaitTime = columnStopTimes[columns - 1] + smoothStopDuration;
        yield return new WaitForSeconds(maxWaitTime);

        // 依次停止并重置每列（第一列到第五列）
        for (int col = 0; col < columns; col++)
        {
            // 停止协程
            if (columnCoroutines[col] != null)
            {
                StopCoroutine(columnCoroutines[col]);
            }

            // 将麻将移回网格
            for (int row = 0; row < rows; row++)
            {
                if (buttons[col, row] != null)
                {
                    buttons[col, row].transform.SetParent(buttonGridPanel);
                    buttons[col, row].transform.localPosition = GetGridPosition(col, row, gridLayout.cellSize, gridLayout.spacing);
                }
            }

            // 销毁临时容器
            if (tempContainers[col] != null)
            {
                Destroy(tempContainers[col]);
            }

            // 等待列间停止间隔（视觉上的依次停止效果）
            if (col < columns - 1)
            {
                yield return new WaitForSeconds(stopInterval);
            }
        }

        isScrolling = false;
    }

    // <summary>
    /// 单列滚动协程 - 从上往下滚动
    /// </summary>
    /// <param name="column">列索引</param>
    /// <param name="tempContainer">临时容器</param>
    IEnumerator ScrollColumn(int column, GameObject tempContainer)
    {
        // 获取网格参数
        Vector2 cellSize = gridLayout.cellSize;
        Vector2 spacing = gridLayout.spacing;

        // 计算行高
        float rowHeight = cellSize.y + spacing.y;
        float maxScrollDistance = rowHeight * (rows - 1);

        // 存储初始值
        int[] initialValues = new int[rows];
        for (int row = 0; row < rows; row++)
        {
            if (buttons[column, row] != null && buttons[column, row].gameObject != null)
            {
                initialValues[row] = buttons[column, row].value;
            }
            else
            {
                initialValues[row] = Random.Range(minValue, maxValue + 1);
            }
        }

        // 记录开始时间
        float startTime = Time.time;
        float elapsedTime = 0f;

        // 固定向下滚动
        bool currentDirection = false; // false = 向下

        // 当前显示的值数组
        int[] currentValues = (int[])initialValues.Clone();

        // 累计滚动距离
        float totalScrollDistance = 0f;

        // 计算基础速度（根据滚动速度参数调整）
        float baseSpeed = 300f * (2.0f - scrollSpeed); // 值越小速度越快

        // 滚动直到时间结束
        while (elapsedTime < scrollDuration)
        {
            // 计算经过的时间
            elapsedTime = Time.time - startTime;

            // 计算速度因子（随时间变化）
            float speedFactor = 1f;

            // 检查是否应该开始停止
            if (useSequentialStop && elapsedTime >= columnStopTimes[column] && !columnStopped[column])
            {
                // 开始平滑停止
                columnStopped[column] = true;
                yield return StartCoroutine(SmoothStopColumn(column, tempContainer, currentValues, elapsedTime));
                break;
            }

            // 前10%时间加速
            if (elapsedTime < scrollDuration * 0.1f)
            {
                speedFactor = Mathf.Lerp(0.3f, 1.2f, elapsedTime / (scrollDuration * 0.1f));
            }
            // 后10%时间减速（如果不使用依次停止）
            else if (!useSequentialStop && elapsedTime > scrollDuration * 0.9f)
            {
                speedFactor = Mathf.Lerp(1.2f, 0.1f, (elapsedTime - scrollDuration * 0.9f) / (scrollDuration * 0.1f));
            }
            // 中间80%时间保持稳定速度
            else
            {
                speedFactor = 1.0f;
            }

            // 计算当前帧的滚动距离
            float scrollDelta = baseSpeed * speedFactor * Time.deltaTime;

            // 向下滚动
            if (!currentDirection)
            {
                scrollDelta = Mathf.Abs(scrollDelta);
            }

            // 检查临时容器是否还存在
            if (tempContainer == null)
            {
                yield break; // 如果容器被销毁，直接退出协程
            }

            // 应用滚动 - 向下移动
            tempContainer.transform.Translate(0, -scrollDelta, 0);
            totalScrollDistance += scrollDelta;

            // 检查是否滚动了一行高度
            if (totalScrollDistance >= rowHeight)
            {
                // 重置累计距离
                totalScrollDistance -= rowHeight;

                // 调整位置以保持连续性
                tempContainer.transform.localPosition += new Vector3(0, rowHeight, 0);

                // 更新值的循环效果
                // 保存最下方的值
                int bottomValue = currentValues[0];

                // 所有值向上移动
                for (int i = 0; i < rows - 1; i++)
                {
                    currentValues[i] = currentValues[i + 1];
                }

                // 最上方设为原最下方值
                currentValues[rows - 1] = bottomValue;

                // 更新按钮显示的值
                for (int row = 0; row < rows; row++)
                {
                    if (buttons[column, row] != null)
                    {
                        buttons[column, row].SetValue(currentValues[row], triggerValue);
                    }
                }
            }

            yield return null;
        }

        // 确保最终位置正确
        if (tempContainer != null)
        {
            tempContainer.transform.localPosition = Vector3.zero;
        }

        // 应用最终值
        for (int row = 0; row < rows; row++)
        {
            if (buttons[column, row] != null)
            {
                buttons[column, row].SetValue(currentValues[row], triggerValue);
            }
        }
    }

    /// <summary>
    /// 平滑停止单列滚动 - 从上往下
    /// </summary>
    /// <param name="column">列索引</param>
    /// <param name="tempContainer">临时容器</param>
    /// <param name="currentValues">当前值数组</param>
    /// <param name="elapsedTime">已经过时间</param>
    IEnumerator SmoothStopColumn(int column, GameObject tempContainer, int[] currentValues, float elapsedTime)
    {
        float remainingTime = smoothStopDuration;
        float startSpeed = 300f * (2.0f - scrollSpeed);
        bool currentDirection = false; // 固定向下滚动

        while (remainingTime > 0)
        {
            // 检查临时容器是否还存在
            if (tempContainer == null)
            {
                yield break; // 如果容器被销毁，直接退出协程
            }

            // 计算减速因子
            float stopProgress = 1f - (remainingTime / smoothStopDuration);
            float speedFactor = stopCurve.Evaluate(stopProgress);
            float currentSpeed = startSpeed * speedFactor;

            // 应用滚动 - 向下移动
            float scrollDelta = currentSpeed * Time.deltaTime;
            tempContainer.transform.Translate(0, -scrollDelta, 0);

            remainingTime -= Time.deltaTime;
            yield return null;
        }

        // 确保位置归零
        if (tempContainer != null)
        {
            tempContainer.transform.localPosition = Vector3.zero;
        }
    }

    /// <summary>
    /// 计算麻将按钮在网格中的位置 - 调整从上往下布局
    /// </summary>
    /// <param name="column">列索引</param>
    /// <param name="row">行索引</param>
    /// <param name="cellSize">单元格大小</param>
    /// <param name="spacing">间距</param>
    /// <returns>麻将的本地位置</returns>
    Vector3 GetGridPosition(int column, int row, Vector2 cellSize, Vector2 spacing)
    {
        // 计算面板总尺寸
        float panelWidth = columns * (cellSize.x + spacing.x) - spacing.x;
        float panelHeight = rows * (cellSize.y + spacing.y) - spacing.y;

        // 计算X位置（从左到右）
        float xPos = column * (cellSize.x + spacing.x) + cellSize.x / 2 - panelWidth / 2;

        // 计算Y位置（从上到下，0=最顶部，rows-1=最底部）
        // 修改为从上往下排列：第0行在最上面，最后一行在最下面
        float yPos = panelHeight / 2 - row * (cellSize.y + spacing.y) - cellSize.y / 2;

        return new Vector3(xPos, yPos, 0);
    }

    #endregion

    /// <summary>
    /// 验证数组状态，确保麻将数量正确
    /// </summary>
    void ValidateButtonArray()
    {
        int expectedCount = columns * rows;
        int actualCount = GetCurrentButtonCount();

        Debug.Log($"=== 麻将数量验证 ===");
        Debug.Log($"期望数量: {expectedCount} (列:{columns} × 行:{rows})");
        Debug.Log($"实际数量: {actualCount}");

        if (actualCount != expectedCount)
        {
            Debug.LogError($"❌ 麻将数量不匹配！期望: {expectedCount}, 实际: {actualCount}");

            // 打印详细的数组状态
            Debug.Log("=== 详细数组状态 ===");
            for (int col = 0; col < columns; col++)
            {
                string colStatus = $"第{col}列: ";
                for (int row = 0; row < rows; row++)
                {
                    if (buttons[col, row] == null)
                    {
                        colStatus += "[空] ";
                    }
                    else if (buttons[col, row].gameObject == null)
                    {
                        colStatus += "[销毁] ";
                    }
                    else
                    {
                        colStatus += $"[{buttons[col, row].value}] ";
                    }
                }
                Debug.Log(colStatus);
            }

            // 统计每列的数量
            Debug.Log("=== 每列数量统计 ===");
            for (int col = 0; col < columns; col++)
            {
                int colCount = 0;
                for (int row = 0; row < rows; row++)
                {
                    if (buttons[col, row] != null && buttons[col, row].gameObject != null)
                    {
                        colCount++;
                    }
                }
                Debug.Log($"第{col}列: {colCount}个麻将");
            }
        }
        else
        {
            Debug.Log($"✅ 麻将数量正确: {actualCount}");
        }
        Debug.Log("==================");
    }

    /// <summary>
    /// 强制重置所有麻将位置，确保位置正确
    /// </summary>
    IEnumerator ResetAllButtonPositions()
    {
        // 获取网格参数
        Vector2 cellSize = gridLayout.cellSize;
        Vector2 spacing = gridLayout.spacing;

        // 等待一帧确保所有操作完成
        yield return null;

        // 重置所有麻将位置
        for (int col = 0; col < columns; col++)
        {
            for (int row = 0; row < rows; row++)
            {
                if (buttons[col, row] != null && buttons[col, row].gameObject != null)
                {
                    // 确保麻将在正确的父级下
                    if (buttons[col, row].transform.parent != buttonGridPanel)
                    {
                        buttons[col, row].transform.SetParent(buttonGridPanel);
                    }

                    // 重置位置
                    Vector3 targetPos = GetGridPosition(col, row, cellSize, spacing);
                    buttons[col, row].transform.localPosition = targetPos;
                    buttons[col, row].transform.localScale = Vector3.one;
                }
            }
        }

        // 再次等待一帧确保位置更新
        yield return null;
    }

    /// <summary>
    /// 获取当前麻将按钮数量
    /// </summary>
    /// <returns>当前麻将按钮数量</returns>
    int GetCurrentButtonCount()
    {
        int count = 0;
        for (int col = 0; col < columns; col++)
        {
            for (int row = 0; row < rows; row++)
            {
                if (buttons[col, row] != null && buttons[col, row].gameObject != null)
                {
                    count++;
                }
            }
        }
        return count;
    }

    #region 触发消除机制
    
    /// <summary>
    /// 检查并处理触发值
    /// 消除值为triggerValue的麻将
    /// </summary>
    IEnumerator CheckTriggerValues()
    {
        List<CardGridButton_UICtrl> toRemove = new List<CardGridButton_UICtrl>();

        // 检查所有麻将
        for (int col = 0; col < columns; col++)
        {
            for (int row = 0; row < rows; row++)
            {
                // 检查是否是触发值
                if (buttons[col, row] != null &&
                    buttons[col, row].gameObject != null &&
                    buttons[col, row].isTriggerValue)
                {
                    // 添加到移除列表
                    toRemove.Add(buttons[col, row]);
                    buttons[col, row] = null; // 清空数组引用
                }
            }
        }

        // 如果有需要移除的麻将
        if (toRemove.Count > 0)
        {
            yield return StartCoroutine(RemoveAndRefillButtons(toRemove));
        }
    }

    /// <summary>
    /// 移除麻将并重新填充空格
    /// </summary>
    /// <param name="toRemove">要移除的麻将列表</param>
    IEnumerator RemoveAndRefillButtons(List<CardGridButton_UICtrl> toRemove)
    {
        isRefilling = true; // 设置重新填充状态

        // 第一步：麻将消失动画
        Sequence disappear = DOTween.Sequence();
        foreach (var btn in toRemove)
        {
            if (btn != null && btn.gameObject != null)
            {
                // 缩小消失
                disappear.Join(btn.transform.DOScale(Vector3.zero, 0.3f).SetEase(Ease.InBack));
            }
        }
        yield return disappear.WaitForCompletion();

        // 第二步：销毁麻将对象
        foreach (var btn in toRemove)
        {
            if (btn != null && btn.gameObject != null)
            {
                Destroy(btn.gameObject);
            }
        }

        // 第三步：重新填充空格
       // yield return StartCoroutine(RefillEmptySpaces());

        isRefilling = false; // 重置填充状态
    }

    /// <summary>
    /// 重新填充空格
    /// 1. 现有麻将下落填补空格
    /// 2. 在顶部生成新麻将
    /// </summary>
    IEnumerator RefillEmptySpaces()
    {
        // 获取网格参数
        Vector2 cellSize = gridLayout.cellSize;
        Vector2 spacing = gridLayout.spacing;
        float rowHeight = cellSize.y + spacing.y;

        // 调试：打印填充前的状态
        Debug.Log($"开始重新填充，当前麻将数量: {GetCurrentButtonCount()}");

        // 逐列处理
        for (int col = 0; col < columns; col++)
        {
            // 找出当前列的所有空格（从上到下）
            List<int> emptyRows = new List<int>();
            for (int row = 0; row < rows; row++)
            {
                if (buttons[col, row] == null || buttons[col, row].gameObject == null)
                {
                    emptyRows.Add(row);
                }
            }

            // 按行号排序（大的在前，小的在后）
            emptyRows = emptyRows.OrderByDescending(row => row).ToList();

            // 如果没有空格则跳过
            if (emptyRows.Count == 0) continue;

            Debug.Log($"第{col}列有{emptyRows.Count}个空格需要填充");

            // 第一步：现有麻将下落
            Sequence dropSequence = DOTween.Sequence();
            Dictionary<int, int> rowMapping = new Dictionary<int, int>(); // 记录行映射关系

            // 从下往上处理，避免覆盖问题
            for (int row = rows - 1; row >= 0; row--)
            {
                // 只处理有麻将的位置
                if (buttons[col, row] != null && buttons[col, row].gameObject != null)
                {
                    // 计算当前麻将下方有多少空格
                    int emptyBelow = emptyRows.Count(r => r > row);

                    // 如果有空格麻将需要下落
                    if (emptyBelow > 0)
                    {
                        // 计算麻将新位置
                        int newRow = row + emptyBelow;

                        // 记录映射关系
                        rowMapping[row] = newRow;

                        // 计算目标位置
                        Vector3 targetPos = GetGridPosition(col, newRow, cellSize, spacing);

                        // 添加下落动画
                        dropSequence.Join(
                            buttons[col, row].transform.DOLocalMoveY(targetPos.y, 0.5f)
                                .SetEase(Ease.OutBack) // 弹性效果
                        );
                    }
                }
            }

            // 等待下落动画完成
            yield return dropSequence.WaitForCompletion();

            // 更新数组引用（在下落动画完成后）
            foreach (var mapping in rowMapping)
            {
                buttons[col, mapping.Value] = buttons[col, mapping.Key];
                buttons[col, mapping.Key] = null;
            }

            // 第二步：在顶部生成新麻将
            Sequence createSequence = DOTween.Sequence();
            for (int i = 0; i < emptyRows.Count; i++)
            {
                // 获取目标行（从下往上）
                int targetRow = emptyRows[emptyRows.Count - 1 - i];

                // 确保目标位置为空
                if (buttons[col, targetRow] != null)
                {
                    Debug.LogWarning($"警告：目标位置[{col},{targetRow}]不为空，跳过创建");
                    continue;
                }

                // 计算起始位置（在目标位置上方）和目标位置
                Vector3 startPos = GetGridPosition(col, -1 - i, cellSize, spacing);
                Vector3 endPos = GetGridPosition(col, targetRow, cellSize, spacing);

                // 创建新麻将
                GameObject btnObj = Instantiate(buttonPrefab, buttonGridPanel);
                btnObj.transform.localPosition = startPos;
                btnObj.transform.localScale = Vector3.zero; // 初始不可见

                // 设置麻将控制器
                CardGridButton_UICtrl btn = btnObj.GetComponent<CardGridButton_UICtrl>() ??
                                          btnObj.AddComponent<CardGridButton_UICtrl>();
                int value = Random.Range(minValue, maxValue + 1);
                btn.SetValue(value, triggerValue);

                // 存储引用
                buttons[col, targetRow] = btn;

                Debug.Log($"在第{col}列第{targetRow}行创建新麻将，值:{value}");

                // 添加生成动画+移动
                createSequence.Join(
                    btnObj.transform.DOScale(Vector3.one, 0.3f).SetEase(Ease.OutBack) // 缩放动画
                );
                createSequence.Join(
                    btnObj.transform.DOLocalMoveY(endPos.y, 0.6f) // 移动动画
                        .SetEase(Ease.OutBounce) // 弹性效果
                        .SetDelay(i * 0.1f) // 错开生成时间
                );
            }
            // 等待生成动画完成
            yield return createSequence.WaitForCompletion();
        }

        // 位置校准，确保所有麻将位置正确
        for (int col = 0; col < columns; col++)
        {
            for (int row = 0; row < rows; row++)
            {
                if (buttons[col, row] != null && buttons[col, row].gameObject != null)
                {
                    buttons[col, row].transform.localPosition = GetGridPosition(col, row, cellSize, spacing);
                }
            }
        }

        // 调试：打印填充后的状态
        Debug.Log($"重新填充完成，当前麻将数量: {GetCurrentButtonCount()}");

        // 更新内容尺寸
        UpdateContentSize();

        // 验证初始化后的麻将数量
        //ValidateButtonArray();
    }

    #endregion
}